System and method for generic configuration management system application programming interface

ABSTRACT

The technology disclosed can query configuration management system data and includes cross table selection criteria and joined data return.

CLAIM OF PRIORITY

This United States patent application is a continuation of U.S. patentapplication Ser. No. 14/244,555 filed Apr. 3, 2014, entitled “SYSTEM ANDMETHOD FOR GENERIC CONFIGURATION MANAGEMENT SYSTEM APPLICATIONPROGRAMMING INTERFACE,” now U.S. Pat. No. 9,521,040 issued Dec. 13,2016, which claims priority to U.S. Provisional Patent Application No.61/807,905 filed Apr. 3, 2013, entitled “SYSTEM AND METHOD FOR GENERICCONTENT MANAGEMENT SYSTEM APPLICATION-PROGRAMMING INTERFACE,”, theentire contents of which are incorporated herein by reference.

TECHNICAL FIELD

Embodiments relate to configuration management in a computingenvironment. More particularly, embodiments relate to interfaces for usewith generic configuration management system.

BACKGROUND

Organizations typically employ many different types of software andcomputing technologies to meet their computing needs. However,installing and maintaining software on an organization's own computersystems may involve one or more drawbacks. For example, when softwaremust be installed on computer systems within the organization, theinstallation process often requires significant time commitments, sinceorganization personnel may need to separately access each computer. Onceinstalled, the maintenance of such software typically requiressignificant additional resources. Each installation of the software mayneed to be separately monitored, upgraded, and/or maintained. Further,organization personnel may need to protect each installed piece ofsoftware against viruses and other malevolent code. Given thedifficulties in updating and maintaining software installed on manydifferent computer systems, it is common for software to becomeoutdated. Also, the organization will likely need to ensure that thevarious software programs installed on each computer system arecompatible. Compatibility problems are compounded by frequent upgrading,which may result in different versions of the same software being usedat different computer systems in the same organization.

Accordingly, organizations increasingly prefer to use on-demand servicesaccessible via the Internet rather than software installed on in-housecomputer systems. On-demand services, often termed “cloud computing”services, take advantage of increased network speeds and decreasednetwork latency to provide shared resources, software, and informationto computers and other devices upon request. Cloud computing typicallyinvolves over-the-Internet provision of dynamically scalable and oftenvirtualized resources. Technological details can be abstracted from theusers, who no longer have need for expertise in, or control over, thetechnology infrastructure “in the cloud” that supports them.

BRIEF DESCRIPTION OF THE DRAWINGS

Embodiments of the invention are illustrated by way of example, and notby way of limitation, in the figures of the accompanying drawings inwhich like reference numerals refer to similar elements.

FIG. 1 is a block diagram of one embodiment of an architecture in whichgeneric configuration management can be utilized.

FIG. 2 is a block diagram of one embodiment of a computing environmentin which generic configuration management can be utilized.

FIG. 3 is a conceptual diagram of one embodiment of a group ofinterfaces to support generic configuration management.

FIG. 4 illustrates a block diagram of an environment where an on-demanddatabase service might be used.

FIG. 5 illustrates a block diagram of an environment where an on-demanddatabase service might be used.

DETAILED DESCRIPTION

In one embodiment, the technology disclosed can configuration managementsystem data and includes cross table selection criteria and joined datareturn. Other aspects and advantages are illustrated in the drawings,the detailed description and the claims, which follow.

The following detailed description is made with reference to thefigures. Sample implementations are described to illustrate thetechnology disclosed, not to limit its scope, which is defined by theclaims. Those of ordinary skill in the art will recognize a variety ofequivalent variations on the description that follows.

In one embodiment, the technology disclosed provides for both logicalconfiguration and physical inventory. This allows for dynamicconfiguration hierarchies to be supported. Typical configurationmanagement systems are flat with simple key-value pairs. The technologydisclosed provides a more complex, dynamic hierarchy of configurations.For example, in a cloud provider environment, there can be differentconfigurations for different data centers, SUPERPODS, PODS, otherclusters, servers, networks, etc. Thus, the technology disclosesprovides configuration functionality for on demand service environmentsincluding, for example, multitenant database environments.

In one embodiment, the technology disclosed relates to genericconfiguration management system application programming interface (API)for use in a computer-implemented system. The described subject mattercan be implemented in the context of any computer-implemented system,such as a software-based system, a database system, a multi-tenantenvironment, or the like. Moreover, the described subject matter can beimplemented in connection with two or more separate and distinctcomputer-implemented systems that cooperate and communicate with oneanother. One or more implementations may be implemented in numerousways, including as a process, an apparatus, a system, a device, amethod, a computer readable medium such as a computer readable storagemedium containing computer readable instructions or computer programcode, or as a computer program product comprising a computer usablemedium having a computer readable program code embodied therein.

In one embodiment, API version validation capability allows foradditional configuration items to be added/removed/changed with supportof multiple versions of these configurations. In one embodiment, thisversion validation capability automatically applies to all configurationitems/resources that are added (e.g., via annotations) without having toimplement versioning for each configuration item.

In one embodiment, support is provided for REST APIs for multipleresource in a generic manner by scanning and caching class metadata tobuild database queries and responses. This capability allows generationof REST API configuration systems (e.g., deployment configurations) andcan be extended for use with non-configuration systems.

FIG. 1 is a block diagram of one embodiment of an architecture in whichgeneric configuration management can be utilized. Architecture 100 canprovide services to any number of remote electronic devices (e.g.,workstation 102, laptop 104, servers 106 and/or servers 108). In oneembodiment, the one or more electronic devices are coupled tocommunicate through load balancer 120, which may operate to balance thenetwork traffic to and from the remote electronic devices.

In one embodiment, there is provided an interface between load balancer120 and application server 140. In one embodiment, the interface is aHyperText Transfer Protocol (HTTP)/REST JSON (Representational StateTransfer (REST) JavaScript Object Notation (JSON) interface. Inalternate embodiments, other interfaces can also be supported. JSON is alight-weight data serialization format based on a subset of JavaScript.A RESTful interface is one that conforms to the constraints andcharacteristics of the REST architectural style.

In one embodiment, application server 140 also includes an interface todatabase load balancer 180. In one embodiment, database load balancer180 is coupled with one or more real application cluster (RAC) nodes(e.g., 184, 186), which can access database 190. In one embodiment,database load balancer 180, RAC node 184, RAC node 186 and database 190are part of a multitenant database environment. Various features andembodiments of multitenant database environments are described ingreater detail below.

Application controller can include various components, for example,Spring Model View Controller (MVC), 150 and/or Spring Service 152,and/or Spring Repository 154. Other and/or different components may alsobe provided/utilized by application server 140. Spring is merely anexample technology and others embodiments can also be supported.Hibernate layer 156 operates to integrate database functionality of theunderlying database with JAVA-based functionality. Other technologiescan also be used.

The technology disclosed herein can query configuration managementsystem (CMS) data and includes cross table selection criteria and joineddata return. It can further include bulk creation of rows in a singletable, bulk update of rows in a single table, bulk deletion of row in asingle table, cascading deletes through top level objects, creation ofrows in multiple class types in a single call through top level objects,update rows in multiple class types in a single call through top levelobjects, pagination of “get” methods, etc.

In some implementations, it can include writing to non-CMS data sources,supporting federation to external sources including federating fulltables to non-CMS data sources, selecting criteria that include non-CMSdata sources, joining of columns from external sources logically into anobject in the CMS to return column data from an external source. Inother implementations, it can include data processes such as uniqueness,null allowed, and referential integrity. It can also include partialfield/property updates of resources where user may pass only the fieldsthat need to be updated and queries with “other than and” as theoperator.

In one embodiment, the API can adhere to most or all of the REST APIstandards. The base URL on which the “create, read, update, delete”(CRUD) operations can be built may be, for example,{cms-server}/api/{version}/{resource}, where {resource} can represent adomain object. It can be used to abstract the REST API from the schemaof the persistence layer. In some implementations, “{resource}” can bemapped to a domain object on one-to-one basis.

In some implementations, the API can be accessed using standard RESTconventions. The API method can be modeled as a resource and invokedusing one of the HTTP verbs: POST, GET, PUT, and DELETE. These HTTPverbs can directly correlate with the database CRUD operations.

In one embodiment, the resource associations can diverge from the RESTstandards because these associations can be added as part of theresponse like an object graph instead of hypertext links. Thus it cansupport: typed APIs or Java client bindings; updates from top-levelobjects; and/or partial updates.

In one embodiment, all CRUD operations can be performed through the mainresources or top-level objects. For example, in FIG. 2, the Host 220,Cluster 225, SuperPod 230 and DataCenter 235 objects can be top-levelobjects, which can support the CRUD operations. In some implementations,read operations can also support various resources, includingnon-top-level objects. The top-level objects of FIG. 2 are exampleimplementations and other implementations can also be supported.

Furthermore, top-level objects can be updated by modifications that canbe specific to the top-level objects. For example, in FIG. 2, host andits related objects can be updated by specifying an update to the hostobject.

In some implementations, processes supported by architecture illustratedin FIG. 2 can include updating device object (i.e., updating the hostobjects with embedded device information). It can also include addingmore network interfaces for the host (i.e., retrieving the host forupdate), then adding the new network interface to the host object andmaking an update API call to update the host. It can include deleting anetwork interface for the host (i.e. retrieving the host for update),deleting the interface object from the host and making an update APIcall to update the host. It can further include adding a host to acluster, in which case the host can be related to the cluster and canmake a “create API” call.

In one embodiment, exposed objects 210 are the exposed portion of theinterfaces described herein. In one embodiment, exposed objects 210includes the top-level objects (e.g., Host 220, Cluster 225, SuperPod230, DataCenter 235) as well as Device 240, NetworkInterface 245,HostBusAdapter 250, FiberChannelNode 255, and FiberChannelPort 260.Exposed objects 210 provide an interface to one or more configurationobjects that provide configuration functionality.

FIG. 3 is a block diagram of one embodiment of a computing environmentin which generic configuration management can be utilized. The blockdiagram of FIG. 3 provides a lower-level description of the applicationserver (e.g., application server 140 of FIG. 1) and the relevantcomponents to provide generic configuration management.

Web server 310 is any type of web server that provides content to, orrequests content from database 390. Some components (e.g., loadbalancers) are not illustrated in FIG. 3 in order to not distract fromthe description of the configuration management techniques utilizedherein.

Generic controller 320 handles methods (e.g., CRUD, find, describe,list, distinc) for supported resources. In one embodiment, genericcontroller uses the Spring @RequestMapping annotation for each method toindicate the URL pattern to handle API requests in a generic manner. AnAPI request can be matched to one of the URL patterns, the version canbe validated and the request can be matched to its resource type(whether top-level or not). Once validations are successful, the requestcan be handed off to generic service layer 330.

In one embodiment, exceptions can be handled in a generic manner in thislayer as well. The following is an example controller method for adelete.

/**  * Delete resource;  *  * @param version The version requested bythe client  * @param resource Type type of resource to be deleted  *@param id the id of resource to be deleted  */ @RequestMapping (produces= “application/json”, value = “/{version:{circumflex over ( )}[1- 9][0-9]*\\.[0-9] [0-9]*$}/{resource}/{id}”, method = RequestMethod.DELETE)@Responsebody public CMSResponse delete (@PathVariable(“version”) Doubleversion, @PathVariable (“resource”) String resourceType,@PathVariable(“id”) String id) {    return deleteResource (version,resourceType, id); } private CMSResponse deleteResource(Double version,String resourceType, String id) {    CmsApiVersionHandler versionHandler= new CmsApiVersionHandler (version);   versionHandler.verifyVersion(versionValidator);   cmsService.delete(apiResourceCache.- getClassName(resourceType), id);   return new CMSSuccessResponse( ); }

In one embodiment, query model 340 stores the parsed request and is usedby multiple modules for different purposes. In one embodiment, querymodel 340 is used by Repository/DAO layer 350 to dynamically generate aORM (e.g., Hibernate) 380 query to find resources saved in database 390for handling, for example, start, limit, searchCriteria and expand, etc.In one embodiment, query model 340 is used by generic controller layer320 to parse JSON output fields and for handling the fields queryparameter in the request.

In one embodiment, generic service layer 330 performs CRUD operationsissued by controller 320. Depending on the operation requested bycontroller 320, generic service layer 330 performs the create, find,delete or update operation on the appropriate data in the repository.Generic service layer 330 then wraps the result of the operation andpasses it back to controller 320. In one embodiment, generic servicelayer 330 uses the API resource cache 365 and/or API version validator360 to perform the operation on the correct resource and version. Thefollowing is example code for delete:

Public void delete(String objectType, String id) {   Logger.info(“delete({ },{ }) called”, objectType, id);    If(objectType == null || id == null)  {    Logger.error(“Exception duringdelete( )”);       Throw newCmsRuntimeException(REQUIRED_PARAMETER_NOT_FOUND);    }ConfigurationItem configurationItem = get(newRequestQueryModel(objectType, id)); If(configurationItem == null)  {   Logger.error(“Excpetion during delete( )”);    Throw new      ResourceNotFoundException (      String.format(CANNOT_FIND_ENTITY_WITH_ID,apiResourceCache.getResourceName(objectType), id));    }   logger.info(“delete({ },{ }) completed”, objectType, id);   standardDao.delete(configurationItem); }

In one embodiment, the response (e.g., HTTP header) can include the HTTPstatus code. In one embodiment, the response body can include thefollowing elements:

Response Element Description Success True if the API call is successful;false, otherwise. Data If the API call is successful, this can depend onthe operation: Create/update API - the resource (and its associatedresources can be returned) in JSON format so that the client can havethe ids for the created objects. Get/find API - the resource(s) in JSONformat that satisfy the input condition. Total The total number of rootresources. Message This can contains the error message if the API callfailed.

Sample succesful response follows: {  “success”: true,  “data”: [  { “id”: “bb3f02be-812e-4500-b4cd-292be253de22”  “name”:“na55-acs1-1-was”,  “deviceRole”: “acs”,  }]  “total”: 1 } Sample errorresponse follows: {  “success”: false,  “message”: “Error message here”}

In one embodiment, API version validator 360 checks to determine thatnew fields for each resource are only accessible on the API version thatthey are introduced, and that the fields that are deprecated are notaccessible after a particular version. In one embodiment, fields areannotated with a version number with a MinApiVersion and MaxApiVersionto indicate when these attributes/resources are effective. In oneembodiment, adding attributes will have a MinApiVersion value of therelease when it got added. In one embodiment, deprecating fields aredeprecating the old name and adding the new name. In one embodiment,annotations both at the resource and field level. The following is asample of a domain object with versions on the resource and its fields.

@Entity @Table(name = “CMDB_HOST”) @JsonFilter(“Host”)@JsonIdentityInfo(generator = ObjectIdGenerators.UUIDGenerator.class,property= “@hostJacksonId”) @APIResource(name = “hosts”)@MinApiVersion(1.0) public class Host extends AuditableConfigurationItem{    @MinApiVersion(1.0)    @Column(name = “name”)    private Stringname;    @Column(name = “smbiosguid”, nullable = false)    privateString smbiosguid;    @Column(name = “asset_tag”, nullable = false)   private String assetTag;    @MaxApiVersion(2.0) //field is “deleted”by 2.1    @Column(name = “serial_number”, nullable = false)    privateString serialNumber;    @MinApiVersion(1.0)    @MaxApiVersion(2.0)   @Column(name = “operational_status”)    private StringoperationalStatus;    @MinApiVersion(2.1)    @Column(name =“operational_status”)    private String status

In one embodiment, before handling a creation, read or update of aresource and its fields, API version validator 360 validates that theresource and fields are accessible based on the version number providedin the URL. If there is a match, the operation is allowed on theresource/configuration item. In one embodiment, when the resource objectis built for a particular API request, these annotations are taken intoconsideration as well to ensure that the object is compatible with theversion that the client is asking for. In one embodiment, this isaccomplished using appropriate filtering on the JSON response object.

In one embodiment, API resource cache 365 caches metadata informationabout one or more resources. When an application starts for the firsttime, it scans the code (e.g., JAVA®) package to look for resources itcould use for the REST API and caches that information. It is then usedby the different modules of the system to look up information about theresources. The following are examples of resource details that can besaved in the cache: 1) operations allowed for a resource; 2) mapping ofthe REST API name of the resource to the actual class that supports thatresource (e.g., hosts resource->Host.java); and/or 3) a list offields/attributes available in the class. Other and/or differentresource details can also be stored.

In one embodiment, domain objects/resources 370 can be, for example,JAVA® objects that can be referred to with getter and setter methods.Additional and/or different domain objects/resources can also besupported. In one embodiment, domain objects/resources 370 are madeavailable through the REST API. These classes can contain annotationsfor both ORM (e.g., Hibernate) 380 and version handling. In oneembodiment, API resource cache 365 scans the domain objects with@APIResource and @APISearchable annotations. The following is an exampleof a domain object/resource:

@Entity @org.hibernate.annotations.Entity(dynamicInsert = true)@Table(name = “CMDB_HOST”, uniqueConstraints =@UniqueConstraint(columnNames = (“serial_number”, “manufacturer”)))@JsonFilter(“Host”)@JsonIdentityInfo(generator =ObjectIdGenerators.UUIDGenerator.class, property = “@hostJacksonId”)@APIResource(name = “hosts”) public class Host extendsAuditableConfigurationItem  {    @Column(name = “name”, nullable = true,unique = true)    private String name;    @Column(name =“serial_number”, nullable = false)    private String serialNumber;   @Column(name = “operational_status”, nullable = false)    privateString operationalStatus;    @OneToOne(fetch = FetchType.EAGER)   @JoinColumn(name = “cluster_id”, nullable = false)    private Clustercluster;    @MinApiVersion(1.01)    @Column(name = “manufacturer”,nullable = false) ...    public String getName( ) {       return name;   }    public void setName(String name)  {       this.name = name;    }...

In one embodiment, repository/data access object (DAO) layer 350 handlesrequests handled by query model 340 and hands it off to ORM 380 forprocessing. In one embodiment, the class uses the @Repository annotationin Spring; however, other annotation schemes can be used. The followingsample calls can be used within DAO layer 350.

@Repository public class StandardDao implements Dao { @Autowired@Qualifier((“cmsSessionFactory”) private SessionFactory sessionFactory;@Override @Transactional(readOlnly = true)  public List find(QueryModelqueryModel) {   logger.info(“find({ }) called”);   Criteria criteria =queryModel.getHibernateCriteria(sessionFactory);   List list =criteria.list( );   Logger.info(find( ) complete”);   Return list; }@Override @Transactional public void delete(ConfigurationItemconfigurationItem)  {   logger.info(“delete({ }) called”,configurationItem);   sessionFactory.getCurrentSession().delete(configurationItem);   logger.info(‘delete({ }) completed”,configurationItem);   } }

In one embodiment, HTTP POST can be used to support creation of atop-level resource and its non-top-level resource associations per call.The format of the create call can be, for example:

-   -   POST        {cms-server}/api/{version}/{resource}?<method={delete/update}>

In some implementations, “method” can be used when bulk delete or updateis required or by clients who may not be able to perform puts ordeletes.

In one embodiment, the fields to be created can be sent as JavaScriptObject Notation (JSON) in the request body. The parent resourceassociation in the request and its children resources may be included.For example, for Cluster the request can be

-   -   POST {cms-server}/api/{version}/cluster

With request body as follows:

{  “name”: “na7”,  “isDR”: false,  “operationalStatus”:“PRE_PRODUCTION”,  “environment”: “production”,  “buildType”: “new”, “clusterType”: “pod”,  “superpod”: {  “id”:“cc3f02be-812e-4500-b4cd-292be253de43”,  “name”: “sp7”  } }

In one embodiment, a successful create response can return a 201 HTTPstatus code and the body can contain the full JSON object with the newid assigned to it.

{  “success”: true,  “data”: [  {  “id”:“783f02be-812e-4500-b4cd-292be253de43”  “name”: “na7”,  “isDR”: false, “operationalStatus”: “PRE_PRODUCTION”,  “environment”: “production”, “buildType”: “new”,  “clusterType”: “pod”,  “superpod”: {  “id”:“cc3f02be-812e-4500-b4cd-292be253de43”,  “name”: “sp7”  }  }]  “total”:1 }

In one embodiment, a HTTP PUT can be used to update a top-levelresource. Fields can be replaced by the new values passed in. In someimplementations, the update request can be preceded by a retrieval ofthe full and the response can be used as input to the update call. Inone embodiment, the format of the update call can be as follows:

-   -   PUT {cms-server}/api/{version}/{resource}/{id}

For example, allocating the scratch host a name, role and its podassignment can involve retrieving the cluster/pod where the host canbelong to, retrieving the host information from the previous step,changing the host name, role and cluster association, and calling updateAPI with the host object built from the previous step.

A sample update API call is shown below:

PUT {cms-server}/api/{version}/host    with request body of    {   “id”: “bb3f02be-812e-4500-b4cd-292be253de43”    “name”:“na55-acs1-1-was”,    “smbiosguid”: “123”,    “assetTag”: “456345”,   “provisioningStatus”: “inventory complete”,    “deviceType”: “app”,   “deviceRole”: “acs”,    “make”: “Dell”,    “model”: “R620”,   “numberOfLocalDisk”: 2,    “cluster”: {    “name”: “na55”,    “id”:“aa3f02be-812e-4500-b4cd-292be253de43”    },    “networkInterfaces”: [   {    “id”: “993f02be-812e-4500-b4cd-292be253de12”   “hardwareAddress”: “aa:bb:11:22:33:01”,    “logicalName”: “eth0”   },    {    “id”: “993f02be-812e-4500-b4cd-292be253de13”   “hardwareAddress”: “aa:bb:11:22:33:02”,    “logicalName”: “eth1”   },    {    “id”: “993f02be-812e-4500-b4cd-292be253de14”   “hardwareAddress”: “aa:bb:11:22:33:03”,    “logicalName”: “eth2”   },    {    “id”: “993f02be-812e-4500-b4cd-292be253de15”   “hardwareAddress”: “aa:bb:11:22:33:04”,    “logicalName”: “eth3”   },    {    “id”: “993f02be-812e-4500-b4cd-292be253de16”   “hardwareAddress”: “aa:bb:11:22:33:05”,    “logicalName”: “eth4”   },    {    “id”: “993f02be-812e-4500-b4cd-292be253de17”   “hardwareAddress”: “aa:bb:11:22:33:06”,    “logicalName”: “eth5”   },    {    “id”: “993f02be-812e-4500-b4cd-292be253de18”   “hardwareAddress”: “aa:bb:11:22:33:07”,    “logicalName”: “eth6”   },    {    “id”: “993f02be-812e-4500-b4cd-292be253de19”   “hardwareAddress”: “aa:bb:11:22:33:08”,    “logicalName”: “eth7”   },    {    “id”: “993f02be-812e-4500-b4cd-292be253de20”   “hardwareAddress”: “aa:bb:11:22:33:09”,    “logicalName”: “eth8”    }   ]    }

In one embodiment, for concurrent updates, optimistic locking throughthe use of version number can be used.

In one embodiment, HTTP DELETE can be used for deleting a singleresource. The format of the delete call can be as follows:

-   -   DELETE {cms-server}/api/{version}/{resource}/{id}

In some implementations, cascading deletes based on top-level object canbe supported.

In one embodiment, for read API, the technology disclosed can supportfind and get functionality. Both of these can be implemented as HTTP GETmethods. By default, all of its non-top-level children associations canbe returned. If users need its parent association, users need to includethat parent in the expand parameter which is explained below. If usersneed to limit the response with only certain properties, users need touse the field parameter below.

In one embodiment, top-level object reads can return the full objecthierarchy that can include its non-top-level objects. Non-top-levelobject reads can return just that resource.

In one embodiment, Get is used when the ID of the resource is known andthe goal is simply to return that resource. The get call can include theresource name and the ID of the resource to be retrieved. The format ofthe get call can be as follows:

   GET {cms-server}/api/{version}/{resource}/{id}?<fields={field1,field2...,fieldn}>&<expand={fieldObject1,fieldObject2.fieldObject9,...,fieldObjectN}

An example call can be

-   -   GET {cms-server}/api/{version}/host/bb3f02be-812e-450

In some implementations, the supported parameters can include “fields”and “expand.” Fields can represent the limited list of properties thatcan be returned for a resource. If no field parameter is specified, thenall properties of that resource can be returned. The “fields” can befiltered at resource-level, so if cluster name is used in “fields”, nomatter where in object hierarchy cluster comes, it can be returned withname only.

In one embodiment, Expand can include the names of the associatedresources that need to be expanded. If no expand parameter is specified,then the associated resources may not be included in the response. Avalue of “none” means no association (children or parent) is to beincluded. This is useful if users want to capture the properties of aresource and can result in higher performance.

In some implementations, “find” can be used to do more generic queriesand support cross table selection criteria as well as returning nestedobjects. By default, all of its non-top-level children associations canbe returned. If users need its parent association, users need to includethat parent in the expand parameter which is explained below. If usersneed to limit the response with only certain properties, users need touse the field parameter below.

The optional parameters that can be supported on a find can be, forexample:

start—sets the position of the first row to retrieve to supportpagination

limit—sets the maximum number of records to return

fields—the limited list of properties that can be returned for theresource. If no field parameter is specified then all properties of thatresource can be returned. Including fields incurs additional cost on theCMS server side. The fields can be filtered at resource-level, so ifcluster.name is used in fields, no matter where in object hierarchycluster comes, it can be returned with name only.

search criteria—name-value pairs that represent the field to be searchedand the value the field. Note that the field to be searched is of theformat {associated_resource.}field where associated_resource is notrequired if the field resides in the resource. This is basically toallow the query of an object graph to filter the result set.

For example, the following search criteria can exist for a resource host

-   -   cluster.name=na1,application.name=core

which can ask for host resources that can be for cluster na1 and haveapplication core as discovered through tables joined to the host object.

expand—the names of the associated resources that need to be expanded.If no expand parameter is specified, then the associated resources maynot be included in the response. Having “expand” can incur additionalcost on the CMS server side. The names of the potentially nested objectsthat can be returned on the response. A value of “none” means noassociation (children or parent) can be included. This is useful ifusers want to capture the properties of a resource and can result inhigher performance.

For example the following field specification can exist for a get ofresource Superpod

-   -   expand=cluster,cluster.host

The response to this call can return the Superpod as the main resourceand can include the cluster, and host resources associated to thatSuperpod that met the selection criteria.

If users want to find Superpod with name=“abcd”.

-   -   URL: /api/{version}/cms/superpod?name=abcd

This can return [“id”:“abcd”, “name”:“abcd”]. Superpod has associatedresources of cluster but they may not be returned because it is notincluded in the expand parameter.

If users want to get clusters within a Superpod,

-   -   URL: /api/{version}/superpod?name=abcd&expand=clusters

This can return superpod with the cluster resource.

{  “success”: true,  “data”: [  {  “name”: “sp6”,  “id”:“cc3f02be-812e-4500-b4cd-292be253de43”  “clusters”: [  {  “name”: “na7”, “isDR”: false,  “operationalStatus”: “PRE_PRODUCTION”,  “environment”:“production”,  “buildType”: “new”,  “clusterType”: “pod”  }  ]  }] “total”: 1 }

In one embodiment, the APIs can have a version number as part of theURL. The clients need to specifically indicate which version they wantto use.

-   -   {cms-server}/api/{version}/{resource}

If the APIs change drastically to another kind, the technology disclosedcan change the URL path. For example, if users switch to an RPC type ofAPI, the technology disclosed can update the API URL to be:

-   -   {cms-server}/rpc-api/{version}/{resource}

Security can be based on mutual authentication via TLS. In someimplementations, the technology disclosed can also investigatesupporting Kerberos to allow for users to authenticate for cases wherethe updates to CMS can be done through scripts or a user interface (UI).

In one embodiment, authenticated users can query all tables. For updatesthe following authorization models can be used

Resources Authorization Strategy Data center/pod/super pod authorizedthrough LDAP or Kerberos Application tables LDAP or Kerberos (futurerequirement) Inventory assets if authenticated through certificate thenupdates automatically allowed.

In some implementations, client libraries can be provided for Java andPerl. ConfigurationItem is the base object that all other objects, suchas host, application, etc, extend. An instance of a top-level object canbe passed in to these calls and the appropriate action can be taken.Note that for update, a get call must be issued in advance.

public void create(ConfigurationItem configItem); public voiddelete(ConfigurationItem configItem) or public void delete(String id);public void update(ConfigurationItem configItem);

For gets and finds, there can be a GetParams object that can bepopulated with the following fields to inform how the get can be done.The fields can be

List<String> fields List<String> expandObjects List<NameValuePair>searchCriteria

In some implementations, a get call for the resources can be made asfollows:

public Cluster getCluster(String id, GetParams params); public HostgetHost(String id, GetParams params);

In some implementations, a find call for the resources can be made asfollows:

public List<Cluster> findCluster(GetParams params); public List<Host>findHost(GetParams params);

Software Components and Layers can include jetty, MVC, controller layer,service layer. These are specific examples as illustrated in FIG. 1 andother components can also be used. Jetty is the application server thatpowers the CMS APIs. It handles the HTTP requests and forwards it toSpring's Dispatcher servlet.

In one embodiment, users can utilize the Spring MVC framework todispatch requests to the controllers.

Controller Layer—This layer contains all the classes with a controllerrole. These classes use Spring's @Controller annotation. By using thisannotation, user can inform Spring which service interfaces need to beinvoked for certain URL's. This layer takes care of processing the HTTPinput parameters and request body. Spring auto-serializes the responsein the intended output format or media type.

Service Layer—This layer contains all the classes with Spring's @Serviceannotation. Users put the business logic in this layer.

Repository/DAO Layer—This layer contains the classes with Spring's@Repository annotation to indicate that these can be the data accessobjects. This is where users use Hibernate to connect and make DB calls.

Hibernate is an object-relational mapping (ORM) tool to map the domainobjects (POJOs) to the database tables and from Java data types to SQLdata types. It supports optimistic locking automatically with the use ofversion numbers that users added in our domain objects. Users rely onHibernate for the connection pool mechanism and actual DB calls. Usersplan to use some of its annotations as well to indicate whether fieldscan be inserted, updated, etc.

Other implementations may include a non-transitory computer readablestorage medium storing instructions executable by a processor to performa method as described above. Yet another implementation may include asystem including memory and one or more processors operable to executeinstructions, stored in the memory, to perform a method as describedabove.

FIG. 4 illustrates a block diagram of an environment 410 wherein anon-demand database service might be used. Environment 410 may includeuser systems 412, network 414, system 416, processor system 417,application platform 418, network interface 420, tenant data storage422, system data storage 424, program code 426, and process space 428.In other embodiments, environment 410 may not have all of the componentslisted and/or may have other elements instead of, or in addition to,those listed above.

Environment 410 is an environment in which an on-demand database serviceexists. User system 412 may be any machine or system that is used by auser to access a database user system. For example, any of user systems412 can be a handheld computing device, a mobile phone, a laptopcomputer, a work station, and/or a network of computing devices. Asillustrated in FIG. 4 (and in more detail in FIG. 5) user systems 412might interact via a network 414 with an on-demand database service,which is system 416.

An on-demand database service, such as system 416, is a database systemthat is made available to outside users that do not need to necessarilybe concerned with building and/or maintaining the database system, butinstead may be available for their use when the users need the databasesystem (e.g., on the demand of the users). Some on-demand databaseservices may store information from one or more tenants stored intotables of a common database image to form a multi-tenant database system(MTS). Accordingly, “on-demand database service 416” and “system 416”will be used interchangeably herein.

A database image may include one or more database objects. A relationaldatabase management system (RDMS) or the equivalent may execute storageand retrieval of information against the database object(s). Applicationplatform 418 may be a framework that allows the applications of system416 to run, such as the hardware and/or software, e.g., the operatingsystem. In an embodiment, on-demand database service 416 may include anapplication platform 418 that enables creation, managing and executingone or more applications developed by the provider of the on-demanddatabase service, users accessing the on-demand database service viauser systems 412, or third party application developers accessing theon-demand database service via user systems 412.

The users of user systems 412 may differ in their respective capacities,and the capacity of a particular user system 412 might be entirelydetermined by permissions (permission levels) for the current user. Forexample, where a salesperson is using a particular user system 412 tointeract with system 416, that user system has the capacities allottedto that salesperson. However, while an administrator is using that usersystem to interact with system 416, that user system has the capacitiesallotted to that administrator.

In systems with a hierarchical role model, users at one permission levelmay have access to applications, data, and database informationaccessible by a lower permission level user, but may not have access tocertain applications, database information, and data accessible by auser at a higher permission level. Thus, different users will havedifferent capabilities with regard to accessing and modifyingapplication and database information, depending on a user's security orpermission level.

Network 414 is any network or combination of networks of devices thatcommunicate with one another. For example, network 414 can be any one orany combination of a LAN (local area network), WAN (wide area network),telephone network, wireless network, point-to-point network, starnetwork, token ring network, hub network, or other appropriateconfiguration. As the most common type of computer network in currentuse is a TCP/IP (Transfer Control Protocol and Internet Protocol)network, such as the global internetwork of networks often referred toas the “Internet” with a capital “I,” that network will be used in manyof the examples herein. However, it should be understood that thenetworks that the present invention might use are not so limited,although TCP/IP is a frequently implemented protocol.

User systems 412 might communicate with system 416 using TCP/IP and, ata higher network level, use other common Internet protocols tocommunicate, such as HTTP, FTP, AFS, WAP, etc. In an example where HTTPis used, user system 412 might include an HTTP client commonly referredto as a “browser” for sending and receiving HTTP messages to and from anHTTP server at system 416. Such an HTTP server might be implemented asthe sole network interface between system 416 and network 414, but othertechniques might be used as well or instead. In some implementations,the interface between system 416 and network 414 includes load sharingfunctionality, such as round-robin HTTP request distributors to balanceloads and distribute incoming HTTP requests evenly over a plurality ofservers. At least as for the users that are accessing that server, eachof the plurality of servers has access to the MTS' data; however, otheralternative configurations may be used instead.

In one embodiment, system 416, shown in FIG. 4, implements a web-basedcustomer relationship management (CRM) system. For example, in oneembodiment, system 416 includes application servers configured toimplement and execute CRM software applications as well as providerelated data, code, forms, webpages and other information to and fromuser systems 412 and to store to, and retrieve from, a database systemrelated data, objects, and Webpage content. With a multi-tenant system,data for multiple tenants may be stored in the same physical databaseobject, however, tenant data typically is arranged so that data of onetenant is kept logically separate from that of other tenants so that onetenant does not have access to another tenant's data, unless such datais expressly shared.

In certain embodiments, system 416 implements applications other than,or in addition to, a CRM application. For example, system 416 mayprovide tenant access to multiple hosted (standard and custom)applications, including a CRM application. User (or third partydeveloper) applications, which may or may not include CRM, may besupported by the application platform 418, which manages creation,storage of the applications into one or more database objects andexecuting of the applications in a virtual machine in the process spaceof the system 416.

One arrangement for elements of system 416 is shown in FIG. 4, includinga network interface 420, application platform 418, tenant data storage422 for tenant data 423, system data storage 424 for system data 425accessible to system 416 and possibly multiple tenants, program code 426for implementing various functions of system 416, and a process space428 for executing MTS system processes and tenant-specific processes,such as running applications as part of an application hosting service.Additional processes that may execute on system 416 include databaseindexing processes.

Several elements in the system shown in FIG. 4 include conventional,well-known elements that are explained only briefly here. For example,each user system 412 could include a desktop personal computer,workstation, laptop, PDA, cell phone, or any wireless access protocol(WAP) enabled device or any other computing device capable ofinterfacing directly or indirectly to the Internet or other networkconnection. User system 412 typically runs an HTTP client, e.g., abrowsing program, such as Microsoft's Internet Explorer browser,Netscape's Navigator browser, Opera's browser, or a WAP-enabled browserin the case of a cell phone, PDA or other wireless device, or the like,allowing a user (e.g., subscriber of the multi-tenant database system)of user system 412 to access, process and view information, pages andapplications available to it from system 416 over network 414.

Each user system 412 also typically includes one or more user interfacedevices, such as a keyboard, a mouse, trackball, touch pad, touchscreen, pen or the like, for interacting with a graphical user interface(GUI) provided by the browser on a display (e.g., a monitor screen, LCDdisplay, etc.) in conjunction with pages, forms, applications and otherinformation provided by system 416 or other systems or servers. Forexample, the user interface device can be used to access data andapplications hosted by system 416, and to perform searches on storeddata, and otherwise allow a user to interact with various GUI pages thatmay be presented to a user. As discussed above, embodiments are suitablefor use with the Internet, which refers to a specific globalinternetwork of networks. However, it should be understood that othernetworks can be used instead of the Internet, such as an intranet, anextranet, a virtual private network (VPN), a non-TCP/IP based network,any LAN or WAN or the like.

According to one embodiment, each user system 412 and all of itscomponents are operator configurable using applications, such as abrowser, including computer code run using a central processing unitsuch as an Intel Pentium® processor or the like. Similarly, system 416(and additional instances of an MTS, where more than one is present) andall of their components might be operator configurable usingapplication(s) including computer code to run using a central processingunit such as processor system 417, which may include an Intel Pentium®processor or the like, and/or multiple processor units.

A computer program product embodiment includes a machine-readablestorage medium (media) having instructions stored thereon/in which canbe used to program a computer to perform any of the processes of theembodiments described herein. Computer code for operating andconfiguring system 416 to intercommunicate and to process webpages,applications and other data and media content as described herein arepreferably downloaded and stored on a hard disk, but the entire programcode, or portions thereof, may also be stored in any other volatile ornon-volatile memory medium or device as is well known, such as a ROM orRAM, or provided on any media capable of storing program code, such asany type of rotating media including floppy disks, optical discs,digital versatile disk (DVD), compact disk (CD), microdrive, andmagneto-optical disks, and magnetic or optical cards, nanosystems(including molecular memory ICs), or any type of media or devicesuitable for storing instructions and/or data.

Additionally, the entire program code, or portions thereof, may betransmitted and downloaded from a software source over a transmissionmedium, e.g., over the Internet, or from another server, as is wellknown, or transmitted over any other conventional network connection asis well known (e.g., extranet, VPN, LAN, etc.) using any communicationmedium and protocols (e.g., TCP/IP, HTTP, HTTPS, Ethernet, etc.) as arewell known. It will also be appreciated that computer code forimplementing embodiments of the present invention can be implemented inany programming language that can be executed on a client system and/orserver or server system such as, for example, C, C++, HTML, any othermarkup language, Java™, JavaScript, ActiveX, any other scriptinglanguage, such as VBScript, and many other programming languages as arewell known may be used. (Java™ is a trademark of Sun Microsystems,Inc.).

According to one embodiment, each system 416 is configured to providewebpages, forms, applications, data and media content to user (client)systems 412 to support the access by user systems 412 as tenants ofsystem 416. As such, system 416 provides security mechanisms to keepeach tenant's data separate unless the data is shared. If more than oneMTS is used, they may be located in close proximity to one another(e.g., in a server farm located in a single building or campus), or theymay be distributed at locations remote from one another (e.g., one ormore servers located in city A and one or more servers located in cityB).

As used herein, each MTS could include one or more logically and/orphysically connected servers distributed locally or across one or moregeographic locations. Additionally, the term “server” is meant toinclude a computer system, including processing hardware and processspace(s), and an associated storage system and database application(e.g., OODBMS or RDBMS) as is well known in the art. It should also beunderstood that “server system” and “server” are often usedinterchangeably herein. Similarly, the database object described hereincan be implemented as single databases, a distributed database, acollection of distributed databases, a database with redundant online oroffline backups or other redundancies, etc., and might include adistributed database or storage network and associated processingintelligence.

FIG. 5 also illustrates environment 410. However, in FIG. 5 elements ofsystem 416 and various interconnections in an embodiment are furtherillustrated. FIG. 5 shows that user system 412 may include processorsystem 412A, memory system 412B, input system 412C, and output system412D. FIG. 5 shows network 414 and system 416. FIG. 5 also shows thatsystem 416 may include tenant data storage 422, tenant data 423, systemdata storage 424, system data 425, User Interface (UI) 530, ApplicationProgram Interface (API) 532, PL/SOQL 534, save routines 536, applicationsetup mechanism 538, applications servers 500 ₁-500 _(N), system processspace 502, tenant process spaces 504, tenant management process space510, tenant storage space 512, tenant data 514, and application metadata516. In other embodiments, environment 410 may not have the sameelements as those listed above and/or may have other elements insteadof, or in addition to, those listed above.

User system 412, network 414, system 416, tenant data storage 422, andsystem data storage 424 were discussed above in FIG. 4. Regarding usersystem 412, processor system 412A may be any combination of one or moreprocessors. Memory system 412B may be any combination of one or morememory devices, short term, and/or long term memory. Input system 412Cmay be any combination of input devices, such as one or more keyboards,mice, trackballs, scanners, cameras, and/or interfaces to networks.Output system 412D may be any combination of output devices, such as oneor more monitors, printers, and/or interfaces to networks.

As shown by FIG. 5, system 416 may include a network interface 420 (ofFIG. 4) implemented as a set of HTTP application servers 500, anapplication platform 418, tenant data storage 422, and system datastorage 424. Also shown is system process space 502, includingindividual tenant process spaces 504 and a tenant management processspace 510. Each application server 500 may be configured to tenant datastorage 422 and the tenant data 423 therein, and system data storage 424and the system data 425 therein to serve requests of user systems 412.The tenant data 423 might be divided into individual tenant storagespaces 512, which can be either a physical arrangement and/or a logicalarrangement of data.

Within each tenant storage space 512, tenant data 514 and applicationmetadata 516 might be similarly allocated for each user. For example, acopy of a user's most recently used (MRU) items might be stored totenant data 514. Similarly, a copy of MRU items for an entireorganization that is a tenant might be stored to tenant storage space512. A UI 530 provides a user interface and an API 532 provides anapplication programmer interface to system 416 resident processes tousers and/or developers at user systems 412. The tenant data and thesystem data may be stored in various databases, such as one or moreOracle™ databases.

Application platform 418 includes an application setup mechanism 538that supports application developers' creation and management ofapplications, which may be saved as metadata into tenant data storage422 by save routines 536 for execution by subscribers as one or moretenant process spaces 504 managed by tenant management process 510 forexample. Invocations to such applications may be coded using PL/SOQL 534that provides a programming language style interface extension to API532.

A detailed description of some PL/SOQL language embodiments is discussedin commonly owned co-pending U.S. Provisional Patent Application40/828,192 entitled, PROGRAMMING LANGUAGE METHOD AND SYSTEM FOREXTENDING APIS TO EXECUTE IN CONJUNCTION WITH DATABASE APIS, by CraigWeissman, filed Oct. 4, 2006, which is incorporated in its entiretyherein for all purposes. Invocations to applications may be detected byone or more system processes, which manages retrieving applicationmetadata 516 for the subscriber making the invocation and executing themetadata as an application in a virtual machine.

Each application server 500 may be communicably coupled to databasesystems, e.g., having access to system data 425 and tenant data 423, viaa different network connection. For example, one application server 500₁ might be coupled via the network 414 (e.g., the Internet), anotherapplication server 500 _(N-1) might be coupled via a direct networklink, and another application server 500 _(N) might be coupled by yet adifferent network connection. Transfer Control Protocol and InternetProtocol (TCP/IP) are typical protocols for communicating betweenapplication servers 500 and the database system. However, it will beapparent to one skilled in the art that other transport protocols may beused to optimize the system depending on the network interconnect used.

In certain embodiments, each application server 500 is configured tohandle requests for any user associated with any organization that is atenant. Because it is desirable to be able to add and remove applicationservers from the server pool at any time for any reason, there ispreferably no server affinity for a user and/or organization to aspecific application server 500. In one embodiment, therefore, aninterface system implementing a load balancing function (e.g., an F5Big-IP load balancer) is communicably coupled between the applicationservers 500 and the user systems 412 to distribute requests to theapplication servers 500.

In one embodiment, the load balancer uses a least connections algorithmto route user requests to the application servers 500. Other examples ofload balancing algorithms, such as round robin and observed responsetime, also can be used. For example, in certain embodiments, threeconsecutive requests from the same user could hit three differentapplication servers 500, and three requests from different users couldhit the same application server 500. In this manner, system 416 ismulti-tenant, wherein system 416 handles storage of, and access to,different objects, data and applications across disparate users andorganizations.

As an example of storage, one tenant might be a company that employs asales force where each salesperson uses system 416 to manage their salesprocess. Thus, a user might maintain contact data, leads data, customerfollow-up data, performance data, goals and progress data, etc., allapplicable to that user's personal sales process (e.g., in tenant datastorage 422). In an example of a MTS arrangement, since all of the dataand the applications to access, view, modify, report, transmit,calculate, etc., can be maintained and accessed by a user system havingnothing more than network access, the user can manage his or her salesefforts and cycles from any of many different user systems. For example,if a salesperson is visiting a customer and the customer has Internetaccess in their lobby, the salesperson can obtain critical updates as tothat customer while waiting for the customer to arrive in the lobby.

While each user's data might be separate from other users' dataregardless of the employers of each user, some data might beorganization-wide data shared or accessible by a plurality of users orall of the users for a given organization that is a tenant. Thus, theremight be some data structures managed by system 416 that are allocatedat the tenant level while other data structures might be managed at theuser level. Because an MTS might support multiple tenants includingpossible competitors, the MTS should have security protocols that keepdata, applications, and application use separate. Also, because manytenants may opt for access to an MTS rather than maintain their ownsystem, redundancy, up-time, and backup are additional functions thatmay be implemented in the MTS. In addition to user-specific data andtenant specific data, system 416 might also maintain system level datausable by multiple tenants or other data. Such system level data mightinclude industry reports, news, postings, and the like that are sharableamong tenants.

In certain embodiments, user systems 412 (which may be client systems)communicate with application servers 500 to request and updatesystem-level and tenant-level data from system 416 that may requiresending one or more queries to tenant data storage 422 and/or systemdata storage 424. System 416 (e.g., an application server 500 in system416) automatically generates one or more SQL statements (e.g., one ormore SQL queries) that are designed to access the desired information.System data storage 424 may generate query plans to access the requesteddata from the database.

Each database can generally be viewed as a collection of objects, suchas a set of logical tables, containing data fitted into predefinedcategories. A “table” is one representation of a data object, and may beused herein to simplify the conceptual description of objects and customobjects according to the present invention. It should be understood that“table” and “object” may be used interchangeably herein. Each tablegenerally contains one or more data categories logically arranged ascolumns or fields in a viewable schema. Each row or record of a tablecontains an instance of data for each category defined by the fields.

For example, a CRM database may include a table that describes acustomer with fields for basic contact information such as name,address, phone number, fax number, etc. Another table might describe apurchase order, including fields for information such as customer,product, sale price, date, etc. In some multi-tenant database systems,standard entity tables might be provided for use by all tenants. For CRMdatabase applications, such standard entities might include tables forAccount, Contact, Lead, and Opportunity data, each containingpre-defined fields. It should be understood that the word “entity” mayalso be used interchangeably herein with “object” and “table”.

In some multi-tenant database systems, tenants may be allowed to createand store custom objects, or they may be allowed to customize standardentities or objects, for example by creating custom fields for standardobjects, including custom index fields. U.S. patent application Ser. No.10/817,161, filed Apr. 2, 2004, entitled “Custom Entities and Fields ina Multi-Tenant Database System”, and which is hereby incorporated hereinby reference, teaches systems and methods for creating custom objects aswell as customizing standard objects in a multi-tenant database system.In certain embodiments, for example, all custom entity data rows arestored in a single multi-tenant physical table, which may containmultiple logical tables per organization. It is transparent to customersthat their multiple “tables” are in fact stored in one large table orthat their data may be stored in the same table as the data of othercustomers.

Reference in the specification to “one embodiment” or “an embodiment”means that a particular feature, structure, or characteristic describedin connection with the embodiment is included in at least one embodimentof the invention. The appearances of the phrase “in one embodiment” invarious places in the specification are not necessarily all referring tothe same embodiment.

While the invention has been described in terms of several embodiments,those skilled in the art will recognize that the invention is notlimited to the embodiments described, but can be practiced withmodification and alteration within the spirit and scope of the appendedclaims. The description is thus to be regarded as illustrative insteadof limiting.

What is claimed is:
 1. A method for providing dynamic configuration inan environment having one or more interconnected electronic computingdevices utilizing dynamic configuration hierarchies, the methodcomprising: automatically providing, with an application serverutilizing one or more hardware processors, version information for aresource within the environment; scanning, with the one or more hardwareprocessors, class metadata for the resource including at least theversion information via an application program interface (API), whereinthe API is modeled as a resource and is invoked using a HTTP command;checking fields, with the one or more hardware processors, for theresource that are only accessible via an API version that is supportedby the resource and that fields that are deprecated are not accessiblevia the API after a corresponding API version in which the deprecatedfields are not supported, wherein deprecation information is maintainedat a resource level and at a field level; storing the class metadata forthe resource in a repository in a hardware storage device; and making anupdate API call, with the one or more hardware processors, to update adevice object by updating a host object with embedded deviceinformation.
 2. The method of claim 1 wherein the HTTP command comprisesat least one of: POST, GET, PUT and DELETE.
 3. The method of claim 1wherein the update API call functions to add one or more networkinterfaces for the host object.
 4. The method of claim 1 wherein theupdate API call functions to delete one or more network interfaces forthe host object.
 5. The method of claim 1 wherein the application serverand the server computing device are both part of an on-demand servicesenvironment.
 6. The method of claim 5 wherein the on-demand servicesenvironment comprises a multitenant database environment.
 7. Anon-transitory computer-readable medium having stored thereoninstructions that, when executed by one or more processors, areconfigurable to cause the one or more processors to: automaticallyprovide, with an application server utilizing one or more hardwareprocessors, version information for a resource within the environment;scan, with the one or more hardware processors, class metadata for theresource including at least the version information via an applicationprogram interface (API), wherein the API is modeled as a resource and isinvoked using a HTTP command; check fields, with the one or morehardware processors, for the resource that are only accessible via anAPI version that is supported by the resource and that fields that aredeprecated are not accessible via the API after a corresponding APIversion in which the deprecated fields are not supported, whereindeprecation information is maintained at a resource level and at a fieldlevel; store the class metadata for the resource in a repository in ahardware storage device; and make an update API call, with the one ormore hardware processors, to update a device object by updating a hostobject with embedded device information.
 8. The non-transitorycomputer-readable medium of claim 7 wherein the HTTP command comprisesat least one of: POST, GET, PUT and DELETE.
 9. The non-transitorycomputer-readable medium of claim 7 wherein the update API callfunctions to add one or more network interfaces for the host object. 10.The non-transitory computer-readable medium of claim 7 wherein theupdate API call functions to delete one or more network interfaces forthe host object.
 11. The non-transitory computer-readable medium ofclaim 7 wherein the application server and the server computing deviceare both part of an on-demand services environment.
 12. Thenon-transitory computer-readable medium of claim 11 wherein theon-demand services environment comprises a multitenant databaseenvironment.
 13. A system comprising: a physical memory device; one ormore processors coupled with the physical memory device, the one or moreprocessors configurable to automatically provide, with an applicationserver utilizing one or more hardware processors, version informationfor a resource within the environment, to scan, with the one or morehardware processors, class metadata for the resource including at leastthe version information via an application program interface (API),wherein the API is modeled as a resource and is invoked using a HTTPcommand, to check fields, with the one or more hardware processors, forthe resource that are only accessible via an API version that issupported by the resource and that fields that are deprecated are notaccessible via the API after a corresponding API version in which thedeprecated fields are not supported, wherein deprecation information ismaintained at a resource level and at a field level, to store the classmetadata for the resource in a repository in a hardware storage device,and to make an update API call, with the one or more hardwareprocessors, to update a device object by updating a host object withembedded device information.
 14. The system of claim 13 wherein the HTTPcommand comprises at least one of: POST, GET, PUT and DELETE.
 15. Thesystem of claim 13 wherein the update API call functions to add one ormore network interfaces for the host object.
 16. The system of claim 13wherein the update API call functions to delete one or more networkinterfaces for the host object.
 17. The system of claim 13 wherein thesystem functions to provide an on-demand services environment.
 18. Thesystem of claim 17 wherein the on-demand services environment comprisesa multitenant database environment.